package com.xinyi.basic.base.widget

import android.content.Context
import android.os.Handler
import android.os.Message
import android.util.AttributeSet
import android.widget.LinearLayout
import androidx.annotation.CallSuper
import com.xinyi.basic.action.ActivityAction
import com.xinyi.basic.thread.ThreadHandler

/**
 * @author 杨耿雷
 * @date 2024/10/8 9:14
 * @description 自定义LinearLayout基类, 主要封装了Handler消息处理和线程操作以及生命周期管理
 */
abstract class BaseLinearLayout: LinearLayout, Handler.Callback, ActivityAction {

    /**
     * 在工作线程上进行处理的Handler
     */
    private var mThreadHandler: ThreadHandler? = null

    /**
     * 是否处于Resume状态
     */
    private var isResume: Boolean = false

    constructor(context: Context?) : super(context!!) {
        initWidget(null)
    }

    constructor(context: Context?, attrs: AttributeSet?) : super(context!!, attrs) {
        initWidget(attrs)
    }

    constructor(context: Context?, attrs: AttributeSet?, defStyleAttr: Int) : super(context!!, attrs, defStyleAttr) {
        initWidget(attrs)
    }

    private fun initWidget(attrs: AttributeSet?) {
        inflate(context, initLayoutId(), this)

        initViews()
        initStyledAttributes(attrs)
        initParams()
        initListeners()
    }

    /**
     * 初始化样式属性
     * @param attrs 属性集
     */
    protected open fun initStyledAttributes(attrs: AttributeSet?) {}

    /**
     * 初始化布局ID
     *
     * @return 返回ID
     */
    protected abstract fun initLayoutId(): Int

    /**
     * 初始化组件
     */
    protected open fun initViews() {}

    /**
     * 参数设置
     */
    protected open fun initParams() {}

    /**
     * 监听设置
     */
    protected open fun initListeners() {}

    /**
     * 初始化UI观察
     */
    @CallSuper
    protected open fun onResume() {
        isResume = true
    }

    /**
     * 视图暂停时调用
     */
    @CallSuper
    protected open fun onPause() {
        isResume = false
    }

    /**
     * 视图销毁时调用
     */
    protected open fun onDestroy() {}

    /**
     * 是否处于Resume状态
     */
    fun isResume(): Boolean {
        return isResume
    }

    /**
     * 在视图附加到窗口时调用
     */
    override fun onAttachedToWindow() {
        super.onAttachedToWindow()
        if (mThreadHandler == null) {
            mThreadHandler = ThreadHandler.createHandler(this)
        }
        onResume()
    }

    /**
     * 当视图从窗口分离时调用
     */
    override fun onDetachedFromWindow() {
        onPause()
        super.onDetachedFromWindow()
        try {
            mThreadHandler?.quit()
            mThreadHandler = null
        } catch (ex: Exception) {
            ex.printStackTrace()
        }
        onDestroy()
    }

    /**
     * 处理消息
     */
    override fun handleMessage(msg: Message): Boolean {
        return false
    }

    /**
     * 在主线程上运行任务
     *
     * @param task 要执行的任务
     */
    @Synchronized
    fun runOnUiThread(task: Runnable?) {
        task ?: return
        mThreadHandler?.runOnUiThread(task)
    }

    /**
     * 在主线程上运行任务
     *
     * @param task 要执行的任务
     * @param duration 延迟执行的时间（毫秒）
     */
    @Synchronized
    fun runOnUiThread(task: Runnable?, duration: Long) {
        task ?: return
        mThreadHandler?.runOnUiThread(task, duration)
    }

    /**
     * 从主线程中移除指定的任务
     *
     * @param task 要移除的任务
     */
    @Synchronized
    fun removeFromUiThread(task: Runnable?) {
        task ?: return
        mThreadHandler?.removeFromUiThread(task)
    }

    /**
     * 将任务添加到队列中，在工作线程中执行
     *
     * @param task 要添加到队列中的任务
     */
    @Synchronized
    fun queueEvent(task: Runnable?) {
        task ?: return
        mThreadHandler?.queueEvent(task)
    }

    /**
     * 将任务添加到队列中，在工作线程中执行
     *
     * @param task 要添加到队列中的任务
     * @param delayMillis 延迟执行的时间（毫秒）
     */
    @Synchronized
    fun queueEvent(task: Runnable?, delayMillis: Long = 0) {
        task ?: return
        mThreadHandler?.queueEvent(task, delayMillis)
    }

    /**
     * 从队列中移除指定的任务
     *
     * @param task 要移除的任务
     */
    @Synchronized
    protected fun removeEvent(task: Runnable?) {
        task ?: return
        mThreadHandler?.removeEvent(task)
    }

    /**
     * 移除队列中的所有任务和消息
     */
    @Synchronized
    protected fun removeCallbacksAndMessages() {
        mThreadHandler?.removeCallbacksAndMessages()
    }

    /**
     * 发送消息到工作线程的消息队列中
     *
     * @param msg 要发送的消息对象
     */
    @Synchronized
    protected fun sendThreadMessageDelayed(msg: Message) {
        mThreadHandler?.sendThreadMessageDelayed(msg, 0)
    }

    /**
     * 发送线程消息/延迟
     *
     * @param msg 要发送的消息对象
     * @param delayMillis 延迟执行的时间（毫秒）
     */
    @Synchronized
    protected fun sendThreadMessageDelayed(msg: Message, delayMillis: Long = 0) {
        mThreadHandler?.sendThreadMessageDelayed(msg, delayMillis)
    }
}
